package com;

import java.awt.*;
import java.util.Objects;

/**
 * Created by hasee on 2015-09-24.
 */
public class Letter {
    static int w, h;
    private static Font font, smfont;
    private static int y0, ys0;
    private static int lasth = -1;
    static final int NORMAL = 0;
    static final int DIM = 1;
    static final int BRIGHT = 2;

    private static Color colors[][] = {
            mix(250, 220, 100), // normal
            mix(200, 150, 80), // dim
            mix(255, 230, 150) // bright
    };
    private static Color mix(int r, int g, int b)[] {
        Color arr[] = new Color[3];
        arr[NORMAL] = new Color(r, g, b);
        arr[DIM] = gain(arr[0], .71);
        arr[BRIGHT] = gain(arr[0], 1.31);
        return arr;
    }
    private static int clamp(double d) {
        return (d < 0) ? 0 : ((d > 255) ? 255 : (int) d);
    }
    private static Color gain(Color c, double f) {
        return new Color(
                clamp(c.getRed() * f),
                clamp(c.getGreen() * f),
                clamp(c.getBlue() * f));
    }

    private boolean valid = false;
    // quantized tile position of Letter. (just stored here).
    private Point tile = null;
    int x, y; // position of Letter.
    private int x0; // offset of symbol on tile.
    private int w0; // width in pixels of symbol.
    private int xs0; // offset of points on tile.
    private int ws0; // width in pixels of points.
    private int gap = 1; // pixels between symbol and points.


    private String symbol;
    private int points;
    Letter(char s, int p) {
        symbol = "" + s;
        points = p;
    }

    public String getSymbol() {
        return symbol;
    }

    public Point recall() {
        return tile;
    }

    public int getPoints() {
        return points;
    }

    void remember(Point t) {
        if (t == null) {
            tile = t;
        } else {
            tile = new Point(t.x, t.y);
        }
    }

    public void paint(Graphics offGraphics, Object dim) {

    }

    public void move(int x, int y) {
        this.x = x;
        this.y = y;
    }

    static void resize(int w0, int h0) {
        w = w0;
        h = h0;
    }

    public boolean hit(int xp, int yp) {
        return (xp >= x && xp < x + w && yp >= y && yp < y + h);
    }

    private int font_ascent;
    void validate(Graphics g) {
        FontMetrics fm;
        if (h != lasth) {
            font = new Font("SansSerif", Font.BOLD, (int)(h * .6));
            g.setFont(font);
            fm = g.getFontMetrics();
            font_ascent = fm.getAscent();
            y0 = (h - font_ascent) * 4 / 10 + font_ascent;
            smfont = new Font("SansSerif", Font.BOLD, (int)(h * .3));
            g.setFont(smfont);
            fm = g.getFontMetrics();
            ys0 = y0 + fm.getAscent() / 2;
            lasth = h;
        }
        if (!valid) {
            valid = true;
            g.setFont(font);
            fm = g.getFontMetrics();
            w0 = fm.stringWidth(symbol);
            g.setFont(smfont);
            fm = g.getFontMetrics();
            ws0 = fm.stringWidth("" + points);
            int slop = w - (w0 + gap + ws0);
            x0 = slop / 2;
            if (x0 < 1)
                x0 = 1;
            xs0 = x0 + w0 + gap;
            if (points > 9)
                xs0--;
        }
    }
    void paint(Graphics g, int i) {
        Color c[] = colors[i];
        validate(g);
        g.setColor(c[NORMAL]);
        g.fillRect(x, y, w, h);
        g.setColor(c[BRIGHT]);
        g.fillRect(x, y, w - 1, 1);
        g.fillRect(x, y + 1, 1, h - 2);
        g.setColor(Color.black);
        g.fillRect(x, y + h - 1, w, 1);
        g.fillRect(x + w - 1, y, 1, h - 1);
        g.setColor(c[DIM]);
        g.fillRect(x + 1, y + h - 2, w - 2, 1);
        g.fillRect(x + w - 2, y + 1, 1, h - 3);
        g.setColor(Color.black);
        if (points > 0) {
            g.setFont(font);
            g.drawString(symbol, x + x0, y + y0);
            g.setFont(smfont);
            g.drawString("" + points, x + xs0, y + ys0);
        }
    }
}
